{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda2/lib/python3.7/site-packages/pandas_datareader/compat/__init__.py:7: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
      "  from pandas.util.testing import assert_frame_equal\n"
     ]
    }
   ],
   "source": [
    "from pandas_datareader import data as datareader\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import timedelta, datetime\n",
    "import math\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.metrics import confusion_matrix, classification_report, accuracy_score\n",
    "from sklearn.metrics import r2_score, matthews_corrcoef, f1_score, mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlfinlab.microstructural_features import get_roll_measure, get_roll_impact\n",
    "from mlfinlab.microstructural_features import get_corwin_schultz_estimator, get_bekker_parkinson_vol\n",
    "from mlfinlab.microstructural_features import get_bar_based_kyle_lambda, get_bar_based_amihud_lambda, get_bar_based_hasbrouck_lambda\n",
    "from ta import add_all_ta_features\n",
    "from ta.utils import dropna\n",
    "from mlfinlab.features.fracdiff import frac_diff_ffd\n",
    "from utils import get_meta_barier, getDailyVol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlfinlab.backtest_statistics import sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import probabilistic_sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import deflated_sharpe_ratio\n",
    "from mlfinlab.backtest_statistics import information_ratio\n",
    "from mlfinlab.backtest_statistics import minimum_track_record_length\n",
    "from mlfinlab.backtest_statistics import drawdown_and_time_under_water"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from yahoofinancials import YahooFinancials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling and Training Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    clf=RandomForestClassifier(n_estimators=1,\n",
    "                               criterion='entropy',\n",
    "                               bootstrap=False,\n",
    "                               class_weight='balanced_subsample')\n",
    "    clf=BaggingClassifier(base_estimator=clf,\n",
    "                         n_estimators=100,\n",
    "                         max_features=1.)\n",
    "    return clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_and_evaluate_n_times(X_train, Y_train, X_test, Y_test):\n",
    "    mmcs, pred_prs = [], []\n",
    "    for n in range(N_SAMPLES):\n",
    "\n",
    "        clf = create_model()\n",
    "\n",
    "        clf.fit(X_train, Y_train)\n",
    "        pred = clf.predict(X_test)\n",
    "        pred_pr = clf.predict_proba(X_test)[:, 1]\n",
    "\n",
    "        mmcs.append(matthews_corrcoef(Y_test, pred))\n",
    "        pred_prs.append(pred_pr)\n",
    "    return mmcs, pred_prs\n",
    "\n",
    "def visualize_mmcs(mmcs):\n",
    "    plt.figure()\n",
    "    plt.title(str(np.mean(mmcs)))\n",
    "    plt.hist(mmcs)\n",
    "    plt.axvline(np.mean(mmcs), color = 'red')\n",
    "    plt.show()\n",
    "    \n",
    "def backtest_predictions(pred_prs, P_test):\n",
    "    bagging_strategies, bagging_returns = [], []\n",
    "    for pred_pr in pred_prs:\n",
    "        signal = [-(1-p) if p <= 0.5 else p for p in pred_pr]\n",
    "        bagging_strategies.append((signal * P_test).cumsum())\n",
    "        bagging_returns.append(signal * P_test)\n",
    "    return bagging_strategies, bagging_returns\n",
    "\n",
    "def visualize_backtests(bagging_strategies, P_test):\n",
    "    plt.figure(figsize = (15, 5))\n",
    "    for strategy in bagging_strategies:\n",
    "        plt.plot(strategy, color = 'grey', ls = '--', lw=0.5)\n",
    "    plt.plot(P_test.cumsum(), lw = 3, label = 'Benchmark')\n",
    "    plt.plot(np.array(bagging_strategies).mean(axis=0), lw = 3, label = 'Strategy')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ohclv_to_features(data):\n",
    "    \n",
    "    try:\n",
    "        frac_diff_series = frac_diff_ffd(pd.DataFrame(np.log(data['close'])), 0.7, thresh=1e-4)\n",
    "    except:\n",
    "        print('Not calculated')\n",
    "        frac_diff_series = pd.DataFrame(np.log(data['close'])).pct_change()\n",
    "        \n",
    "    # Add all ta features\n",
    "    technical_features = add_all_ta_features(\n",
    "        data, open=\"open\", high=\"high\", low=\"low\", close=\"close\", volume=\"volume\")\n",
    "    \n",
    "    data['feat_tech_volume_cmf'] = technical_features['volume_cmf']\n",
    "    data['feat_tech_volatility_dcl'] = technical_features['volatility_dcl']\n",
    "    data['feat_tech_trend_macd_diff'] = technical_features['trend_macd_diff']\n",
    "    data['feat_tech_trend_vortex_ind_diff'] = technical_features['trend_vortex_ind_diff']\n",
    "    data['feat_tech_momentum_stoch_signal'] = technical_features['momentum_stoch_signal']\n",
    "    data['feat_tech_momentum_tsi'] = technical_features['momentum_tsi']\n",
    "    \n",
    "    data['feat_afml_roll_measure'] = get_roll_measure(data['close'], WINDOW)\n",
    "    data['feat_afml_roll_impact'] = get_roll_impact(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_corwin_schultz'] = get_corwin_schultz_estimator(data['high'], data['low'], WINDOW)\n",
    "    data['feat_afml_bekker_parkinson_vol'] = get_bekker_parkinson_vol(data['high'], data['low'], WINDOW)\n",
    "    data['feat_afml_kyle_lambda'] = get_bar_based_kyle_lambda(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_amihud_lambda'] = get_bar_based_amihud_lambda(data['close'], data['volume'], WINDOW)\n",
    "    data['feat_afml_hasbrouck_lambda'] = get_bar_based_hasbrouck_lambda(data['close'], data['volume'], WINDOW)\n",
    "    \n",
    "    data['feat_stat_min_frac_close'] = frac_diff_series.rolling(WINDOW).min()\n",
    "    data['feat_stat_max_frac_close'] = frac_diff_series.rolling(WINDOW).max()\n",
    "    data['feat_stat_mean_frac_close'] = frac_diff_series.rolling(WINDOW).mean()\n",
    "    data['feat_stat_std_frac_close'] = frac_diff_series.rolling(WINDOW).std()\n",
    "    data['feat_stat_skew_frac_close'] = frac_diff_series.rolling(WINDOW).skew()\n",
    "    data['feat_stat_kurt_frac_close'] = frac_diff_series.rolling(WINDOW).kurt()\n",
    "    data['feat_stat_autocorr_frac_close'] = frac_diff_series.rolling(WINDOW).apply(lambda x: x.autocorr(), raw=False)\n",
    "    \n",
    "    FEATURE_COLUMNS = [d for d in data.columns if 'feat_' in d]\n",
    "    dataset = data[FEATURE_COLUMNS]\n",
    "    \n",
    "    dataset_normalized = {}\n",
    "    for feature_column in dataset.columns:\n",
    "        feature_i = dataset[feature_column]\n",
    "        feature_i_norm = (feature_i - feature_i.rolling(WINDOW).mean()) / feature_i.rolling(WINDOW).std()\n",
    "        dataset_normalized[feature_column] = feature_i_norm\n",
    "    dataset_normalized = pd.DataFrame(\n",
    "           dataset_normalized, index = dataset.index\n",
    "    )\n",
    "    \n",
    "    dataset = dataset_normalized\n",
    "    dataset['close'] = data['close']\n",
    "    dataset = dataset.replace([np.inf, -np.inf], np.nan)\n",
    "    dataset = dataset.dropna()\n",
    "    \n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createXY(inputs, outputs, training=False): \n",
    "    \n",
    "    def flatten_features_window(x):\n",
    "        mean = x.mean(axis=1)\n",
    "        std = x.std(axis=1)\n",
    "        low = x.min(axis=1)\n",
    "        high = x.max(axis=1)\n",
    "        open_f = x[:, 0]\n",
    "        close_f = x[:, -1]\n",
    "        return close_f\n",
    "    \n",
    "    X, Y, P, T = [], [], [], []\n",
    "    \n",
    "    # FIXED IID ASSUMPTION (up to some point)\n",
    "    if training:\n",
    "        SKIP = WINDOW + HORIZON\n",
    "    else:\n",
    "        SKIP = 1\n",
    "    \n",
    "    for i in range(INPUT_WINDOW, len(inputs)-HORIZON, SKIP):\n",
    "\n",
    "        if INPUT_WINDOW > 1:\n",
    "            window = inputs[i-INPUT_WINDOW:i].values\n",
    "        else:\n",
    "            window = inputs.iloc[i].values\n",
    "        future = (outputs[i+HORIZON] - outputs[i]) / outputs[i]\n",
    "        future_binary = 1.0 if future > 0 else 0.0\n",
    "\n",
    "        X.append(window)\n",
    "        Y.append(future_binary)\n",
    "        P.append(future)\n",
    "        T.append(outputs.index[i+HORIZON])\n",
    "\n",
    "    X, Y, P = np.array(X), np.array(Y), np.array(P)\n",
    "    \n",
    "    if INPUT_WINDOW > 1:\n",
    "        X = flatten_features_window(X)\n",
    "    return X, Y, P, T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics Routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ar1(x):\n",
    "    return np.corrcoef(x[:-1], x[1:])[0,1]\n",
    "\n",
    "def autocorr_penalty(x):\n",
    "    n = len(x)\n",
    "    p = np.abs(ar1(x))\n",
    "    return np.sqrt(1 + 2*np.sum([((n - i)/n)*p**i for i in range(1,n)]))\n",
    "\n",
    "def smart_sharpe(x):\n",
    "    return (np.mean(x)/(np.std(x, ddof=1) * autocorr_penalty(x)) * np.sqrt(252))\n",
    "\n",
    "def calculate_all_metrics(benchmark_returns, strategy_returns, dates_array):\n",
    "    \n",
    "    res = {}\n",
    "    \n",
    "    benchmark_sharpe = sharpe_ratio(benchmark_returns, entries_per_year=252)\n",
    "    benchmark_sharpe_smart = smart_sharpe(benchmark_returns)\n",
    "    strategy_sharpe = sharpe_ratio(strategy_returns, entries_per_year=252)\n",
    "    strategy_sharpe_smart = smart_sharpe(strategy_returns)\n",
    "    psr = probabilistic_sharpe_ratio(strategy_sharpe, benchmark_sharpe, len(benchmark_returns))\n",
    "    all_strategy_sharpes = []\n",
    "    for r in bagging_returns:\n",
    "        sr_i = sharpe_ratio(r, entries_per_year=252)\n",
    "        all_strategy_sharpes.append(sr_i)\n",
    "    dsr = deflated_sharpe_ratio(strategy_sharpe, all_strategy_sharpes, len(benchmark_returns))\n",
    "    ir = information_ratio(strategy_returns, benchmark=np.mean(benchmark_returns), entries_per_year=252)\n",
    "    mtrl = minimum_track_record_length(strategy_sharpe, benchmark_sharpe)\n",
    "\n",
    "    res['benchmark_mean_returns'] = np.mean(benchmark_returns)\n",
    "    res['strategy_mean_returns'] = np.mean(strategy_returns) \n",
    "    res['benchmark_sharpe'] = benchmark_sharpe\n",
    "    res['benchmark_sharpe_smart'] = benchmark_sharpe_smart\n",
    "    res['strategy_sharpe'] = strategy_sharpe\n",
    "    res['strategy_sharpe_smart'] = strategy_sharpe_smart\n",
    "    res['probabilistic_sharpe_ratio'] = psr\n",
    "    res['deflated_sharpe_ratio'] = dsr\n",
    "    res['information_ratio'] = ir\n",
    "    res['minimum_track_record_length'] = mtrl\n",
    "\n",
    "    return res\n",
    "\n",
    "def calculate_important_features(dataset_train, cutoff_up = 0, cutoff_down = 3, visualize = False):\n",
    "\n",
    "    X_train, Y_train, P_train, T_train = createXY(dataset_train[FEATURE_COLUMNS], dataset_train['close'], training=True)\n",
    "    X_train_df = pd.DataFrame(X_train, columns = FEATURE_COLUMNS)\n",
    "    clf = RandomForestClassifier(n_estimators=100, class_weight='balanced_subsample', criterion='entropy')\n",
    "    clf.fit(X_train_df, Y_train)\n",
    "    explainer = shap.TreeExplainer(clf)\n",
    "    shap_values = explainer.shap_values(X_train_df)\n",
    "    fi0 = np.abs(shap_values[0]).mean(axis=0)\n",
    "    fi1 = np.abs(shap_values[1]).mean(axis=0)\n",
    "    fi = fi0 + fi1\n",
    "    imp = pd.DataFrame({\n",
    "        'feature': X_train_df.columns.tolist(),\n",
    "        'mean': fi\n",
    "    })\n",
    "    imp = imp.set_index('feature')\n",
    "    \n",
    "    if visualize:\n",
    "        imp.sort_values('mean').plot.barh()\n",
    "        \n",
    "    return imp, imp.sort_values('mean')[::-1][cutoff_up:-cutoff_down].index.values.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_all_metrics(benchmark_returns, strategy_returns, dates_array, mmcs, pred_prs):\n",
    "    \n",
    "    res = {}\n",
    "    strategy_returns_mean = strategy_returns.mean(axis=0)\n",
    "    \n",
    "    benchmark_sharpe = sharpe_ratio(benchmark_returns, entries_per_year=252)\n",
    "    benchmark_sharpe_smart = smart_sharpe(benchmark_returns)\n",
    "    strategy_sharpe = sharpe_ratio(strategy_returns_mean, entries_per_year=252)\n",
    "    strategy_sharpe_smart = smart_sharpe(strategy_returns_mean)\n",
    "    psr = probabilistic_sharpe_ratio(strategy_sharpe, benchmark_sharpe, len(benchmark_returns))\n",
    "    all_strategy_sharpes = []\n",
    "    for r in strategy_returns:\n",
    "        sr_i = sharpe_ratio(r, entries_per_year=252)\n",
    "        all_strategy_sharpes.append(sr_i)\n",
    "    dsr = deflated_sharpe_ratio(strategy_sharpe, all_strategy_sharpes, len(benchmark_returns))\n",
    "    ir = information_ratio(strategy_returns_mean, benchmark=np.mean(benchmark_returns), entries_per_year=252)\n",
    "    mtrl = minimum_track_record_length(strategy_sharpe, benchmark_sharpe)\n",
    "    \n",
    "    df_for_ddn = pd.DataFrame.from_dict({'Date': dates_array, \n",
    "                                         'Benchmark': benchmark_returns,\n",
    "                                         'Strategy': strategy_returns_mean})\n",
    "    df_for_ddn = df_for_ddn.set_index('Date')\n",
    "    df_for_ddn['Cumulative_Benchmark'] = df_for_ddn.Benchmark.cumsum().round(2)\n",
    "    df_for_ddn['Cumulative_Strategy'] = df_for_ddn.Strategy.cumsum().round(2)\n",
    "    df_for_ddn['HighValue_Benchmark'] = df_for_ddn['Cumulative_Benchmark'].cummax()\n",
    "    df_for_ddn['HighValue_Strategy'] = df_for_ddn['Cumulative_Strategy'].cummax()\n",
    "    df_for_ddn['Drawdown_Benchmark'] = df_for_ddn['Cumulative_Benchmark'] - df_for_ddn['HighValue_Benchmark']\n",
    "    df_for_ddn['Drawdown_Strategy'] = df_for_ddn['Cumulative_Strategy'] - df_for_ddn['HighValue_Strategy']\n",
    "\n",
    "    res['benchmark_mean_returns'] = np.mean(benchmark_returns)\n",
    "    res['strategy_mean_returns'] = np.mean(strategy_returns) \n",
    "    res['benchmark_sharpe'] = benchmark_sharpe\n",
    "    res['benchmark_sharpe_smart'] = benchmark_sharpe_smart\n",
    "    res['strategy_sharpe'] = strategy_sharpe\n",
    "    res['strategy_sharpe_smart'] = strategy_sharpe_smart\n",
    "    res['probabilistic_sharpe_ratio'] = psr\n",
    "    res['deflated_sharpe_ratio'] = dsr\n",
    "    res['information_ratio'] = ir\n",
    "    res['minimum_track_record_length'] = mtrl\n",
    "    res['benchmark_drawdown'] = df_for_ddn['Drawdown_Benchmark'].quantile(.05)\n",
    "    res['strategy_drawdown'] = df_for_ddn['Drawdown_Strategy'].quantile(.05)\n",
    "    res['mmc_mean'] = np.mean(mmcs)\n",
    "    res['mmc_std'] = np.std(mmcs)\n",
    "    res['mmc_sharpe'] = res['mmc_mean'] / res['mmc_std']\n",
    "    res['model_certainty'] = abs(np.array(np.mean(pred_prs)) - 0.5) / 0.5\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data reading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "TICKER = 'DB'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "aapl_yf = yahoo_financials_tech = YahooFinancials([TICKER])\n",
    "data = aapl_yf.get_historical_price_data('2000-01-01', '2020-08-01', 'daily')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data = pd.DataFrame(data[TICKER]['prices'])\n",
    "data = data.set_index('formatted_date')\n",
    "data_original = data.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "WINDOW = 14\n",
    "INPUT_WINDOW = 1 # REDUCED THE CONTEXT\n",
    "HORIZON = 1\n",
    "N_SAMPLES = 25\n",
    "\n",
    "START_YEAR, WARMUP_END, END_YEAR = 2000, 2010, 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = ohclv_to_features(data_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "FEATURE_COLUMNS = [d for d in dataset.columns if 'feat_' in d]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stochastic data preparation\n",
    "### http://www.turingfinance.com/random-walks-down-wall-street-stochastic-processes-in-python/#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_models_to_reconstruct_ohlcv_from_close(data):\n",
    "    # important note: trained on log data, need to exp later\n",
    "    data2train = np.log(data[['high', 'low', 'open', 'close', 'volume']])\n",
    "    X_prices, Y_prices = data2train['close'], data2train[['high', 'low', 'open']]\n",
    "    X_volume, Y_volume = data2train[['high', 'low', 'open', 'close']], data2train['volume']\n",
    "    \n",
    "    model_prices = tf.keras.models.Sequential([\n",
    "    tf.keras.layers.Dense(20, activation='relu'),\n",
    "    tf.keras.layers.Dense(3)\n",
    "        ])\n",
    "    model_prices.compile('adam', 'mae')\n",
    "    model_prices.fit(X_prices, Y_prices, epochs=50, verbose=False)\n",
    "    \n",
    "    model_volume = tf.keras.models.Sequential([\n",
    "        tf.keras.layers.Dense(20, activation='relu'),\n",
    "        tf.keras.layers.Dense(1)\n",
    "        ])\n",
    "    model_volume.compile('adam', 'mae')\n",
    "    model_volume.fit(X_volume, Y_volume, epochs=50, verbose=False)\n",
    "    return model_prices, model_volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Layer dense is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "WARNING:tensorflow:Layer dense_2 is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model_prices, model_volume = train_models_to_reconstruct_ohlcv_from_close(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_returns(log_returns):\n",
    "    \"\"\"\n",
    "    This method exponentiates a sequence of log returns to get daily returns.\n",
    "    \"\"\"\n",
    "    return np.exp(log_returns)\n",
    "\n",
    "\n",
    "def convert_to_prices(log_returns, s0 = 1e-3):\n",
    "    \"\"\"\n",
    "    This method converts a sequence of log returns into normal returns (exponentiation) and then computes a price\n",
    "    sequence given a starting price, param.all_s0.\n",
    "    \"\"\"\n",
    "    returns = convert_to_returns(log_returns)\n",
    "    price_sequence = [s0]\n",
    "    for i in range(1, len(returns)):\n",
    "        price_sequence.append(price_sequence[i - 1] * returns[i - 1])\n",
    "    return np.array(price_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def brownian_motion_log_returns(delta, sigma, N):\n",
    "    \"\"\"\n",
    "    This method returns a Wiener process. The Wiener process is also called Brownian motion. For more information\n",
    "    about the Wiener process check out the Wikipedia page: http://en.wikipedia.org/wiki/Wiener_process\n",
    "    \"\"\"\n",
    "    sqrt_delta_sigma = math.sqrt(delta) * sigma\n",
    "    return np.random.normal(loc=0, scale=sqrt_delta_sigma, size=N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geometric_brownian_motion_log_returns(delta, mu, sigma, N):\n",
    "    \"\"\"\n",
    "    This method constructs a sequence of log returns which, when exponentiated, produce a random Geometric Brownian\n",
    "    Motion (GBM). GBM is the stochastic process underlying the Black Scholes options pricing formula.\n",
    "    \"\"\"\n",
    "    wiener_process = np.array(brownian_motion_log_returns(delta, sigma, N))\n",
    "    sigma_pow_mu_delta = (mu - 0.5 * math.pow(sigma, 2.0)) * delta\n",
    "    return wiener_process + sigma_pow_mu_delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jump_diffusion_process(delta, lamda, jumps_mu, jumps_sigma, N):\n",
    "    \"\"\"\n",
    "    This method produces a sequence of Jump Sizes which represent a jump diffusion process. These jumps are combined\n",
    "    with a geometric brownian motion (log returns) to produce the Merton model.\n",
    "    \"\"\"\n",
    "    s_n = time = 0\n",
    "    small_lamda = -(1.0 / lamda)\n",
    "    jump_sizes = []\n",
    "    for k in range(0, N):\n",
    "        jump_sizes.append(0.0)\n",
    "    while s_n < N:\n",
    "        s_n += small_lamda * math.log(np.random.uniform(0, 1))\n",
    "        for j in range(0, N):\n",
    "            if time * delta <= s_n * delta <= (j + 1) * delta:\n",
    "                # print(\"was true\")\n",
    "                jump_sizes[j] += random.normalvariate(jumps_mu, jumps_sigma)\n",
    "                break\n",
    "        time += 1\n",
    "    return jump_sizes\n",
    "\n",
    "\n",
    "def geometric_brownian_motion_jump_diffusion_log_returns(delta, mu, sigma, lamda, jumps_mu, jumps_sigma, N):\n",
    "    \"\"\"\n",
    "    This method constructs combines a geometric brownian motion process (log returns) with a jump diffusion process\n",
    "    (log returns) to produce a sequence of gbm jump returns.\n",
    "    \"\"\"\n",
    "    jump_diffusion = jump_diffusion_process(delta, lamda, jumps_mu, jumps_sigma, N)\n",
    "    geometric_brownian_motion = geometric_brownian_motion_log_returns(delta, mu, sigma, N)\n",
    "    return np.add(jump_diffusion, geometric_brownian_motion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x14e736da0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.close.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "mm, sstd = data.close.pct_change().mean(), data.close.pct_change().std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-3.0362694738882632e-05, 0.027893721179395946)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mm, sstd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# x = brownian_motion_log_returns(1, 0.000001, 1000)\n",
    "# x = geometric_brownian_motion_log_returns(1, 0, 0.0312, 1000)\n",
    "\n",
    "# delta, mu, sigma, lamda, jumps_mu, jumps_sigma, N\n",
    "x = geometric_brownian_motion_jump_diffusion_log_returns(1, mm, sstd, 0.1, -0.01, 0.001, 1000)\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Merton Jump-Diffusion Simulation')\n",
    "plt.plot(x.cumsum())\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(x)\n",
    "plt.axvline(x.mean(), ls = '--', color = 'red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "prices_simulation = convert_to_prices(x, 100)\n",
    "hlo_simulated = model_prices.predict(np.log(prices_simulation))\n",
    "hloc_simulated = np.concatenate((np.exp(hlo_simulated), np.expand_dims(prices_simulation, -1)), axis=1)\n",
    "volume_simulated = np.exp(model_volume.predict(np.log(hloc_simulated)))\n",
    "dataset_simulated = pd.DataFrame({\n",
    "    'high': hloc_simulated[:, 0],\n",
    "    'open': hloc_simulated[:, 1],\n",
    "    'low': hloc_simulated[:, 2],\n",
    "    'close': hloc_simulated[:, 3],\n",
    "    'volume': volume_simulated.flatten()\n",
    "},\n",
    "    index = [datetime.today() + timedelta(days=x) for x in range(len(hloc_simulated))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x149e2a278>"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAD2CAYAAADcUJy6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3hUVfrHP2dqeg8ECBB671WQDqKAKIoCNhS7rrq2n20t2FZXd1V2Lasrrn1VLKggdgSkI723EAJJSO+Taef3xx1mMull0ibn8zw83Hvuufe8k0m+c+Y973lfIaVEoVAoFP6HrqkNUCgUCkXDoAReoVAo/BQl8AqFQuGnKIFXKBQKP0UJvEKhUPgphqY2oDQxMTEyISGhqc1QKBSKFsW2bdsypJSxZdublcAnJCSwdevWpjZDoVAoWhRCiBMVtSsXjUKhUPgpSuAVCoXCT1ECr1AoFH5KjX3wQoilwCzgjJSyv6vtBeBCwAocBa6TUua4rj0EXA84gDullN/72HaFQtGKsdlsJCcnY7FYmtqURiMgIID4+HiMRmON+tdmkfW/wL+A90q1/Qg8JKW0CyGeBx4CHhBC9AXmA/2A9sBPQoieUkpHLcZTKBSKSklOTiY0NJSEhASEEE1tToMjpSQzM5Pk5GS6dOlSo3tq7KKRUq4Bssq0/SCltLtONwLxruOLgP9JKUuklMeBI8DImo6lUCgU1WGxWIiOjm4V4g4ghCA6OrpW31h86YNfBHznOu4AnCx1LdnVVg4hxE1CiK1CiK3p6ek+NEfRErAcOkTJseNNbYaihdJaxP0stX29PomDF0I8AtiBD2t7r5TyTeBNgOHDh6vcxa0Ip8PB8dkX4dDpEaPOIWDoMLrdcUtTm6VQ+A31nsELIa5FW3y9UnqSy58COpbqFu9qUyjcWAqKANA7Heg2rMP66itNbJFCUTsSExPp379/ufbHHnuMn376qcp7n3jiCV588cWGMg2o5wxeCHE+8H/ABCllUalLXwMfCSH+gbbI2gPYXJ+xFP5HbmZGU5ugUDQITz75ZFObANRiBi+E+BjYAPQSQiQLIa5Hi6oJBX4UQuwQQrwBIKXcC3wK7ANWAberCBpFWXLSksq1Oay2JrBEoag7DoeDG2+8kX79+nHeeedRXFzMtddey7JlywBYuXIlvXv3ZtiwYdx5553MmjXLfe++ffuYOHEiXbt2ZcmSJT63rcYzeCnlggqa366i/zPAM3UxStFKuK68v73gxEnCe3RtAmMULZnF3+xl3+k8nz6zb/swHr+wX7X9Dh8+zMcff8xbb73F5Zdfzueff+6+ZrFYuPnmm1mzZg1dunRhwQJvGT1w4AC//vor+fn59OrVi1tvvbXGMe41Qe1kVTQrTsyZ09QmKBS1okuXLgwePBiAYcOGkZiY6L524MABunbt6o5bLyvwM2fOxGw2ExMTQ5s2bUhLS/Opbc0qm6Si9eAosVbYbrRX3K5QVEVNZtoNhdlsdh/r9XqKi4vrfK/dbq+id+1RM3hFk5CbkVV9J4WihdOrVy+OHTvmntV/8sknjTq+EnhFk5CRdrLSayWlvuIqFC2ZwMBAXnvtNc4//3yGDRtGaGgo4eHhjTa+ctEomoTclERCgO1dBUOOee9v2zHvakZtWtskdikUtSEhIYE9e/a4z++7775yfSZNmsSBAweQUnL77bczfPhwQIuDL03p5/gKNYNXNAkFGckAfDNK8PMg7+3Xeoty3yj8h7feeovBgwfTr18/cnNzufnmmxttbDWDVzQJllxtk9NVYQN4cMZe/n2BpPtpmLHVSffTzia2TqHwHXfffTd33313k4ytZvCKJsFWkAOAMW4AKwfez+MFdowxNsJ0DoLUXieFwicogVc0CfZCbVNKSGQsHYdcw9w/HeDTmw7iMAURVgiHPvysiS1UKFo+SuAVTYKzqACAkIhYr3Zp0ryGjqcea3SbFAp/Qwm8okmQFm0zSHhse+92k2dZyG4paVSbFAp/Qwm8omkoseAUEBldpg6MyeQ+PL5pRyMbpVDUjpCQkKY2oUqUwFdD0a5dOIqKqu+oqBWixIrFBMHBMd7tAQHu4+O71je2WQqFX6EEvgqKsnI4cfk81i+6valN8Tt0VhsWI+iNAV7tIiDQfVyYsrOxzVIo6oSUkvvvv5/+/fszYMAAd0qC22+/na+//hqAOXPmsGjRIgCWLl3KI4880uB2qTj4Kkg5qW3GCd+tapX4Gr3Vjq2CrKiGgGD3sTNPbXhS1JDvHoTU3b59ZtwAuOC5GnX94osv2LFjBzt37iQjI4MRI0Ywfvx4xo0bx9q1a5k9ezanTp0iJSUFgLVr1zJ//nzf2lsBagZfBelHNR+w0aE23vgavdWBtSKBLzWjlwX5jWiRQlF31q1bx4IFC9Dr9bRt25YJEyawZcsWt8Dv27ePvn370rZtW1JSUtiwYQNjxoxpcLvUDL4K8lKPUzot0M4X/kn786cQO6Bvk9nkL+jtzgpn8DqDZ5E14nQuOTt3EzFogFefpB9WU3jnrcR+uoyYgU2XJlbRjKjhTLux6dChAzk5OaxatYrx48eTlZXFp59+SkhICKGhoQ0+vprBV0Fx+mkALEYoKSzC9PZrJF6zsImt8g+MVid2oyjXLvQe1e+QVEzKvMvL9fnj3Y8A2PzNzw1noEJRC8aNG8cnn3yCw+EgPT2dNWvWMHLkSABGjx7Nyy+/7HbZvPjii4wbN65R7FICXwX2nHQArAbIPKX5znTOwqY0yW8IsEhs5vICb+zSttp7HcXbAejy/us4S1SsvKLpmTNnDgMHDmTQoEFMnjyZv/3tb8TFxQGa+Nvtdrp3787QoUPJyspSAt8ckAXadnq7Ac4kHQCg2CSrukVRA2zFFiLzIDeyvIewa7duXP6QgQPxnjZZpsqN3uGp+rTnx98bzE6FojoKCrQd2UIIXnjhBfbs2cPu3buZN2+eu8/111/P6dOaN8BoNFJYWMgll1zSKPYpga8CXaE2W9c7IOf0MQCspqruUNSEUwePopPgiA4qd61338t5o+0UdKW0f9MTf/PqIxyeD9nU7L0NZqdC0dJRAl8FumLt67/RAYVpSQAVRn4oakfaSU2UQ0IrcMfodIw9/2UcBs+vZu667727lBJ4e05ywxipUPgBfiPwGy+4mL1vf+jTZxotWt5aox2sZ7SvWMWB5f3GitpRcOYEAOaINpX20eH5OR9OyPS6preXEviCmhc4VihaG34h8HZLCeHHD6J74WmfPtdk0Xy/RgfITG3B1WFSAl9finPPABAQFlVpH1FK4KdsdLB74BD3ubG0wOdnN4CFCoV/4BcCn5+T2yDPNVs8QmLM0sYwOPziR9ak2Fw7VIMiYyvtY9d7nxusFqzFFu3Y5nlfnK6FcIVCUR6/UKvsMycb5LmBpQQ+NFNLOKZXm1rrjcMlyqEx7Svt4zSU/6Z0JlF7n42lBF4WqbBVhaIyaizwQoilQogzQog9pdqihBA/CiEOu/6PdLULIcQSIcQRIcQuIcTQhjD+LDlnGmahzWyFbd00oWmbrrlrSi/wKerGWVGOatOp0j57xoVxsIO2B+Espw5o8e8mT5QkumLlg1coKqM2M/j/AueXaXsQ+FlK2QP42XUOcAHQw/XvJuD1+plZNUVZqT5/ptPpxOiAPO9stginEvh6U1yEQ0B028oFfmzfUTx6jYGSUgKffXw3UkoCSgt8ibX8zQqFAqiFwEsp1wBl0/tdBLzrOn4XuLhU+3tSYyMQIYRoV19jK6PItePUl1hdIZJhJu98ETqHz4dqdegsJRSbITSk8l2r5019gXVjXyLU4mkrTk2kpKAIowMOdoAiM+gtDV+hWzocJC1fiXSoN1/hzT/+8Q/69+9P//79efnll0lMTKR3795ceeWV9OnTh7lz51Lkqiexbds2JkyYwLBhw5g+fbo7s+TEiRN54IEHGDlyJD179mTt2rU+s6++ycbaSilTXMepwNm/2A5Aacd4sqsthQbAsdGTN9xWbMEYGFBF75pRVKAtquqMgazrm8+5+7SZu77MDP7AZ18TEB1NwuSx9R6ztaBzFfsonVisfCcd4d2ncrpUk8w4Q3qy5o5bPVDHxF1OzNaGF90dy1YS8Pj/sXbtJsa/uLjBx1PUnuc3P8+BrAM+fWbvqN48MPKBSq9v27aNd955h02bNiGlZNSoUUyYMIGDBw/y9ttvM3bsWBYtWsRrr73GXXfdxR133MHy5cuJjY3lk08+4ZFHHmHp0qUA2O12Nm/ezMqVK1m8eDE//fSTT16DzxZZpZQSqLX/QghxkxBiqxBia3p63WbiJ7rpyHFtiszL9k3YXEFuhnZgMPDxBZIb79CzpYco54OXjz5A8W03+GTM1oLBaqekhjuC/+jqWWwVBXmcSdwPwIjQ7kizwGRpeIFPPv0HAJErl1Fy7JiaySsALUXwnDlzCA4OJiQkhEsuuYS1a9fSsWNHxo7VJnxXXXUV69at4+DBg+zZs4dp06YxePBgnn76aZKTPWuHZ1MXDBs2jMTERJ/ZWN8ZfJoQop2UMsXlgjnjaj8FdCzVL97VVg4p5ZvAmwDDhw+vk4Nb16OE/03Qcct3TnLOnCK6ff29QcX5OdqBycgHE1/mq98eIZBCFUXjA8xFjhqnfHj+ch0XbJHM2uxEX2wh5/QRggBzZDRW81ECMxpebK2Z2szQ4HRybMZM0i9awPjnH2vwcRU1p6qZdmMjhCh3LqWkX79+bNiwocJ7zGYzAHq9HnuZ3Ev1ob4z+K+Bs/lzFwLLS7Vf44qmGQ3klnLl+JybLvuScwK0Bbu8DN9E1BQXaAIvjCba95jObTdsRac3KB98PSkpKqZ9qoNT7Wv2q/f71HdIH2AlIxx6HLbQ/oW3AQiObYc90ECgpZoH+ABp8V7Ijfr6fxSlnqmkt6K1MG7cOL766iuKioooLCzkyy+/ZNy4cSQlJbmF/KOPPuLcc8+lV69epKenu9ttNht79zZ8HqXahEl+DGwAegkhkoUQ1wPPAdOEEIeBqa5zgJXAMeAI8BZwm0+tLm8cuhBtV2ShjxZcSwo1gdcZze42p16HXgl8vcjNzETvBBlWs3WS0PgRLL3lMLLMDuKIuAQcgUYCrHDkq5UcW9lwueFlmVBMvZTsP39Gg42naBkMHTqUa6+9lpEjRzJq1ChuuOEGIiMj6dWrF6+++ip9+vQhOzubW2+9FZPJxLJly3jggQcYNGgQgwcPZv36hi8qX2MXjZRyQSWXplTQVwKNWqnaEKRFuxSf9Z3Xk6I/9hAG6MwegZc6UamLxulwoNPrK76ocJOboa29hwRWvou1IizBOsDz6dq2Uy+OBgQABdgevFdrnLHfR1Z6Iy3lY+2DLGqDlQLuuece7rnnHvd5YmIiBoOBDz74oFzfwYMHs2bNmnLtq1evdh/HxMT41AfvFztZAUyhWnE9q48KNcd9oHmb9HqPs1hWMYNPP94wu2n9jSLX+yNMtYt0ymtj9jpvG9cdEVA+3XBDYMpvBD+QQtEA+I3AB4ZGAmAr9G1uEl2eJ85a6nUYKhH4o5vX+XRcf8VSoEU56c3manp6I8d2de8qPhIHQSFx6AICfW5fRbRNVMW/FTUjISGBPXv2VN+xkfAbgQ+O0L7yOwrr/8fodHr8MEXDPFtZpUGH3glHvvuZtJ3eCySZiX/Ue9zWgPXs/gJz7WbwF4+5g+XnaL+uZgRCp0MfGOxz+yrC1Aix9gpFQ+A3Ah8Sre2xkkWFaEsAdceSr/lX35+kY0TvMZ4LOh1GB9ju/hNZ8+Z63WPNLh8Fuv/LlaxdsKhetvgbJcXaNyx9Ld0r7RLGc32biwCQrvVWQ3CIT22rCCmlV+4bhaIl4TcCHxqpFbjt9/0h1l1yZb2elZGi+dP7m6Lo0c8j5NLgvSZtz/d8W5D5mnBZ8/LJP6KV9+Ohe4nZvgFbsfLhnsVWpNWwNNTBfy7QFrHPCrwpOMxndlVGSZEFg9r7oGih+I3Ah0fFuY9j9m+v17MyXfVXCSlTkKJMlMzBEaPcx8IlXBtnXUryrJle/XZ88Fm97PEn7MXaz8kYVPvZt7GT9n5sH6C9D1UVDPEVeRlavPu3I8qnL96w+AWkU6m/ovniNwIfEhLts2flufLLG0K9Z4gB+d6+WF2pzAy6Im2WHltBbvqQvz/rM9taOg5XyKE5MLSanuXp1qMflz9kwDQ6HoCYPj3d15wNVGgrM1UrL2iMKh8CG/HxUo5s3NEwAytaJE888QQvvvhiU5vhxm8E3mD0TUTF0R9+o80TSwAwh3vPEAOyK889biiT1dBZZmYnrVaklBz/5vt6rxG0RA7//Du/XncHzgJtfcMUFl7rZ3TuNo3PB97DXXM+AaB75xHkud72hviJSqeTM4ufByAusre7/dcBnk+Tky8+2QAjKxS+wW8EvjTJ9ZjMJz71uPs4sExJuYM9KpcRo8U7f0TqwaNe5wcGDmLD+GlY7v8z65csrbuBLZSkJx8lbsNPBO/WZsRR7ePr9JyeQ67DEKB9swqJ6MSfb9KzrZtAL8t/qNaX5H1HaHNMc9cZIyPd7VltPeO023eQvPTMcvcqWgfvvfceAwcOZNCgQVx99dVe13bs2MHo0aMZOHAgc+bMIduVCHHJkiX07duXgQMHMn/+fAAKCwtZtGgRI0eOZMiQISxfvrzcWHWhvsnGmiXB9Yh6kMKTYySsTEk5w9hO8P3BCu8zlXiLy+H1v9GmTJ/IdC3SJnXv98D1dTeyBVJsTgMg+lQWVj10ju9dzR014/0JT7B866NwFBw2OzpzDbOY1YDkI1uJcB2HxsVjMUKADbqG9EDLwqFx5uRRwmJ95yJU1J7UZ5+lZL9v0wWb+/Qm7uGHK72+d+9enn76adavX09MTAxZWVksWbLEff2aa67hn//8JxMmTOCxxx5j8eLFvPzyyzz33HMcP34cs9lMTo6WEuWZZ55h8uTJLF26lJycHEaOHMnUqVMJDq5fKLBfzuBNdawBsWHKDDqc8czSI+M6e12/ZdY7bpdAWQJKvGf32fvKb0k+i81WYWJN/8bl1QguluQHQXh45dWcakP3vnNpr9e+aVmtvo1Wyk/xfAuL7dSTm+7Qs/AePcZib4d/xsnDPh1X0TL45ZdfuOyyy4iJ0fbKREV5XLq5ubnk5OQwYcIEABYuXOhOUzBw4ECuvPJKPvjgAwyuyLwffviB5557jsGDBzNx4kQsFgtJSUn1ttEvZ/DmOszgpZREnDru1RbbvpvXuTEokpvv0NMrWfLER6U2Q5kgpBAseQWe56VpWS0/nKjjytUq0qJ0iofCQBA+zNsj9do8xWopIjjUd6GTxelauZF9HWFct4Esi34Oh8PGavNXbDkmGHFY+1DPTz1e1WMUjUBVM+3mxooVK1izZg3ffPMNzzzzDLt3a6UoP//8c3r16uXTsfxqBn/MVU/K4ARrLWPPLYVF5drCQ8vnlV81+VWuHDHVfX79XXo+Ga9tgNr7q6fUlr5Ai4vvFhlX7hmtkeAizzccS4BvQ16ETvuw2P3Kmz5dwLbla771ly7WEx3Zjc49Z9G1zxzGj5zNS5fqeOFS7c+nOK0VfiNTMHnyZD777DMyM7Xfk6wsTx6s8PBwIiMj3eX33n//fSZMmIDT6eTkyZNMmjSJ559/ntzcXAoKCpg+fTr//Oc/3b+/27fXL9T7LH4l8A8uMvDOVO0l5dayOlTGqfJ/pHpj+XwpcQkTuGDiYv4+R8eHE3UsGXgN/SI6AHB6y0p3P1ORlSITBEeXX0zU21tXFE1xdi6xWZ7XbJA+jml0zeBjl31M8l7fuUucroyR/530utfvQvc+l7L96u2MG9APJ+BI9k0NAkXLol+/fjzyyCNMmDCBQYMGeWWVBHj33Xe5//77GThwIDt27OCxxx7D4XBw1VVXMWDAAIYMGcKdd95JREQEjz76KDabjYEDB9KvXz8effRRn9joVy6aDbO+4MudNwBnyDqTRGynjtXec5bULb9T0603xsAIzh3ai8N5iQwf+38krt8PnKTkjGfhrXOSjcxQCImJBzZ73R+UXVJju/yBNf9aSidga3fB8COSYl/nCNN53D2n//iFjv17VtG5Frh8+qERFRQH1xuZN+Nltrw0BcMZ3xd9V7QMFi5cyMKFCyu8NnjwYDZu3Fiufd268okJAwMD+fe//+1z+/xqBh8S3QNDiLbgcfKNd2p379N/q1X/ay/7gmeu1xKMmYO1EDpR4J3J0mqE8HblP2TCMltX6oK80z8CsHqmkXem6tgwxccKX8qfH/bsKzhsPip5ZrXhBMIiYiq8HBTWnswIiErNJ/dsegqFohnhVwIPYLJpf+wd1v1e43sq8tsm1aIehdFVbMRQWLbyD8R2Kr9oYrC1skXXwnxKDPDUBUsIHRXDjVPu8+njhc771zjHR3Hpwm7HaoSAgIhK+xRG6IjKcXJ61kxO7myYgiMKRV3xO4Ev6aj9MebUIny0MDvXfby2n2DhPXoeX1hzP7HZJfCmYi0+0+76qb5+qY527T3ugjtv1rOht2h1Zf/0xRaKAqBdp3E8evVv9O4/36fPF3pvT2P6ySOV9Kzlc212bPryHyBeBHrSHu9+63WfjKuoOa1tV3htX6/fCXz3EYM4EQsnyu4yqoJThz0bJH6d5uDTcU/z3ayPa3y/KUT7UDFbNOW++0Y9d9yi54GJfyIktB1nwqHEAM+NvQVdsMDou6LpLQKDxUaxuRqhrA967+dmpxytpGPt6Lcjn9BqvGmiVNGRoF1rq+ip8DUBAQFkZma2GpGXUpKZmUlAQM1rKfjVIivAyOG3sT/9X3ROh5S9h2jXr/oFt8yUg0QCuxIE7127FWNA7RJhBYZqAh9cKHECfx9/D05ZwpDhtwJw9016dE7YOvJPHDK+j8Hh26pTzZ2AIrvvF1ZLIfRGr/P8ChK+1ZYah9kGel6YoaR1ra00NfHx8SQnJ5Ney4i5lkxAQADx8TVP8+F3Ao/wuFb2bf6tRgJfnHeGSGDjcMm8Woo7QHB4tLYYVwg5QTB8wDyMJo+P6KeZH2Et0dxA0qDH4AS71YbBZKzkif5FaJ6DxPgG/LIY5v3pYdlR/5JpuZk1K96uD/TktQ9U+t6oGI1GunTp0tRmNGv8zkVTmoLcnTXqd7aM3OQOM+o0Tki4J8oiPxgvcQeIihtIXOdx2olR+0wtKiigNWC32ggtAGuY73LElKXNOX15e5qO22/VkxEGMjWx3s/MdeUNOlHNYrs+xDMhCCrBdxE8CoUP8EuBf/s818uqPLuvm33f/ETCks8BMAXXPoUtQFiprJNZkdUszhq0WXthbuvIQLj782+0TI9Rtf9mVFPOHXEb7cd04vXznsShB2kvvyu5tuRmagL/3eiq309ze++dyjlprcddoGj++KXA9+zTFQBHQW41PSFpyfPu44DQugl8UJAnydD2iVWXohMmbSZblFczF0BLZc+yFRSkZxGw+BEAzG0bLmWDwRTMPQu+o1efS3DoQeeQSClZ+8wrFGXl1OmZRTmaUI+NGFplv+4jRvH6DB1fnqN9EKQm+TajoUJRH/xS4EcPvREAZ1H1i5lOTruPA8PrVgJOb/C4H647/8Eq+wrXlvfC/Ow6jdUS2PP9GvR/uY/fHnzM3RbRzTfpgatDE3gnf3z5AzHvv8HqW++u03MsOdo3rLN7HCqjb59L6TemD2Hx2kL76Xfex2mrYzpThcLH+KXAR8V1xgmI3Pxq+5YmNLwWu5vK8NfLdPxrlo7efS6tsp9wxU1n7fPfmd7x9V8CYEr0bMnuNWxSo4zt0At0DklK8i8AiOw/6vScknwtcZQxpOrslEKn4+a5y+gUPxKA+LUb2PLFqjqNqVD4Gr8U+Ni2nTkUDzGHauDnLhVCG1FBWoGaMm/CTEaPH+EVxVMRQSO0FMQ5f5TPUeEvFOdqceiBBVrOnTX9BF06n9soYzv0oHdInFILadHb7Gx6/b1ax0rbC7XJQWANC3uHtvGErqUm/lirsRSKhsInAi+EuFsIsVcIsUcI8bEQIkAI0UUIsUkIcUQI8YkQouHCKMpgDoggqYuONhlWMk+lVtlXlPrDj4nuXEXPqpk59W9cPfu/1fYbf84NFJvAnl9xrHZJYRHHfmvZ4i9dhbWjXUsgOd2N6PSNExLq1At0DtC5drd2THES9spf2bmq8gIsFeEo1gQ+uJI8NGVp32+g+9huqX7tR6FoDOot8EKIDsCdwHApZX9AD8wHngdeklJ2B7Jp5Bp1oe20GdWx7Ruq7Odw5an6x8U6jOaa5pOsO+GRXSg2QcK+XPb/WH7n4893PUzJzddxYkfLzWsiSryzZfYacl6jja13QnyahGJvP3hq4s+1eo6zSEsVHBxZQSbJCuja6Rz+Pkf7c5K2etSMVCh8iK9cNAYgUAhhAIKAFGAysMx1/V3gYh+NVSOiO/cBIH3/Jvb37sPP9z5RYT+zFXYmCKaPH9dotjn0EFzshDtuKndNl/QbAIc3fNdo9vgaYfUWuCGjZzba2F2TtERuxtW7vNqt2bULSz37LSQitkON+hsDQpne7xwAnFYl8IrmQb0FXkp5CngRSEIT9lxgG5AjpTy76yMZqPAvRQhxkxBiqxBiqy+3HLdJ6AeAc5e22an9ik8q7GcukRhNOubOeMNnY1dHdKlv8LknT2MrtS0+N0Sbeeaf9GzSStyyi7X/eLPR7KsvOpudolIOuc4JExvdBrvdOwxVv/NQ7R5QUoITiChTeL0q+vW+DADpUJudFM0DX7hoIoGLgC5AeyAYOL+m90sp35RSDpdSDo+NrXsUS1li47SwvG5bEt1tjpLyMytzCdjNjbvWfLqUW/f0tCn8dO3t7nOD0HxG9lzPh13hNfOJefMlnI6WkYZSZ3NQUPV2gAZHOL0XVbvurF3VJVFixWqE4KDoGt8TEKiFVAq7CpNUNA98oWxTgeNSynQppQ34AhgLRLhcNgDxQKMWrgyPLr+xZt1/vWfx2SlnCCkGe2Dj5oRZepmO4lIz3E671gNweP0f9N2rfQgJVyqDnV98h861EJyfWbdNO42NocSB1fUjTYls3LGfn6v9SgcXlo+acTprnodfZ7NRYvQs1tYEc4X1GRQAACAASURBVLAWUtluW0qL+TBW+De+EPgkYLQQIkgIIYApwD7gV2Cuq89CYLkPxqoxYeGexbGNvbTQxYydX3j12bnia3QScns3rgq9eMlbrO/jCac86IqwO/DFUndbv03p/HjNbZge9tR5TDvpu3qjDYmpxEFJgODau/W8eK2P669Ww/yJlwAQlaMJ/OoBgrema7/mpw8cxZKXT1FmVqX3n0VvdWCtZdxXYKgm8DEZFtYv/ax2NysUDYAvfPCb0BZT/wB2u575JvAAcI8Q4ggQDbxd37Fqg6lURIwjWo9dB85Cb79s9kmt6lP3HhMa0zQ6dBxDtL5UTmeTJoKOpB1e/eI3/+p1npXcMgTebJFYzYJVl3zGZ/N/aNSxp4x7gBIDGJyQFQJHZ0UwtPsgAPat+pxd4ydxYuzYap+jszmw1jLXalCgp/JT2tGva3ezQtEA+CRdsJTyceDxMs3HgJG+eH5dKF1cwjG0O8XbD6ArE76nS9Zi5NvG929U2wCkyfOjD7TqsBZb6LVLi/TICIOYCrIs5KWdaCzz6kVAicRmNhAZ26fRxzaaQ3C43vqTcfD8lavZvuVjYDt5iZvpaCms0XMMNif2WnruzGZPFlGZ57+pKBQtB7/cyVqWSdMWYTGBrsSz+HVw7VZ6/p4IQEyHro1ukyyVC95odbL6FU+UzF9uERyoIOao4z8+5KeH/9oY5tWLQAvYA5uu1ECQay29Q6ZAbzDRvfdEnAL0GTWP0jLYJHZj7dxLolTxb/JbRzpoRfOmVQh8z14XUmLSFv/OcnSrZ0kgtk3jFw0QRo+DN6RQkpn9i/v8t0X7MBgqFpeoFR80uG31obiwCJMdZKC5qU3BptP88GFhHSgIgLCU6neYWgqKOL5+Gx1TnDj0dV8/0FlqkKtaoWhg/Frgf+8jWDFc+yO1mrSZ8llK7GnuY1NA1QmlGgLroHYA7OgiCC8AncF7xhvg8iZt6iV49GrPzDA/sOaRIE3B2ueXaAfBTRwnCZyVZ53eQLEZojM83+DKRrlYiy0UZmTx0233Yll0FQA9j9f9Z60vUbHwiqbHrwX+yCXRyAu12bnNpPMSeCza7O7fFzTNj2Dy9Fu4/CEDyX21mbwpVfMNvzJbsyc+VbMvLyGAR2be676vuOb1dpuEjp++C4A+sOHTPlTGz4M0adeXfrsDwFwqPH3vL797rhUWc3TIEJLOHUvQCU8GzLrw9Sht7NLfFhWKpsKvBf65q9dy/7wVANhNApPVExvtKNRWMc8ZOqZJbOvUeTy7F+4moesIAExpZwC4YMg0AFJdARkdZkxkyODrPDfqRLOtIm+zeBaxjSWNGx5ZmoLxbQDIKfUZUxLgbU/xA3e5j7ctX+E+zgvyCPPiBbX/8wic1ZNdCcJ7MqFQNBF+LfClcZj1mEttZHUWazPmQQPnN5FFGh0HjMYpoOsRrcxct26awP9ngZ6HFuqZM/VvACwbqwlU59OSn//6r6YxthqSSuW4Lx5St+IpvuDaS15iyYU6frjYE9ViK7NbWeJJD5GR7AlHNTo8HwR3Tf9Trce+87KvEIE6wvNqJ/B7fljHqnsXqw1SCp/SigTe6CXwFGmLYFFt654D3hf0HTSNXaXWeINdBbxfueJT/nrxk+6dlHGzh3LSleLAsOqdxjazRpw+vAnQip9cMP3eano3HHHthnDxhZfz9ALPzmVbgPcax7FSKWYcOZ7F19AC7duRU8CIYdfWafzcdgGEFULasYpTQldE2l8fovOK/7Fj1eo6jalQVESrEXhpNmKya4tpAKbsArKDITI6vpo7G5aw8E7Ywz3iE+IS+JjYvvTpc4m7/caLPkDnmlxadRaaI4XZWjaKS9tMIaZNvya1Zfr4x4mI6uY+dwZqax15gbCnkyCm0POr78zx7GwNLpQcaQd/ulNgMAbWaeygcC1NRuqJndX09BCWo23CSzncuBvDFP5NqxF4ArTVya2faOkKgrOKSI8Eo7Hpoz1sMZ66n6HhlReY2DJIe7vC8iv3waccPEZuWtMU9LYVaLlyzCER1fRsfEraaZFSYcVQHKUjPsXJ4c072ffzBmL2pLj7BZVAUbiOb6+qXf740pyNyirIS6umpweDK+jGml99GgWFoqa0GoEXZi0uO/K5pyjKySMix05BpL6auxoH83BPQWqzufIiz30unsmG3oLwQkjed6TCPjkXzWTfjBkAfHf59ay65wmf2loVtqLalblrTKL6DnAf5/XSMkTu/+wNxO2LaHvG+xuRMBoJDm1X57F0Zm0yYS2sWU1gu9VGgCvCR6Sk4bCqbJQK39B6BN7kiS88MXoUIUVgjWr62TvAlOl3cv8iPa/O1HmlWCjLxVP/xplzNPHc970nmVX26TQsBUXubIkRLmFJ2LWezisrzoNfX7Z8soLUMj5mR5G2ezMwsuYpdhuLngOnuo9HzL4CgB7frHa3ZZb6XHWY6vfBrw/Qfq9sxTUT+H2/eUI2e/1ymFUPLK7X+ArFWVqNwJ/9o/Nqa9emCSwpT1zcYF5f8CYXz7my2r4Thy8CIP/0dndb6uSJrLloLtkpZxrKRC9Kii2EPH4fR+fN9WqPcuXeD4us++y3oUjoMcp9PHLIjeWuZ0RqycnAO41EXTAGatE7tuKa5b1JObLa67zrd59TlF+zexWKqmg9Ah9UXuAju/RtAksqpmPHMUw99+Fq+3XopmVGdOZp/m676+t8x1PHObl/m7tfQbb3tvyMpBSyTvvmA+DELq0cXlS+d0a09qe0GWt4bM2rIDUWQUExfD5G8OIlFX9L2jPMzN6e2iq2NPtG4B01FHhLVnlfferxg/WyQaGAViTwxqDyvu2eY6Y0gSX1I65dbyxG0LkKgpw56XGTpO3f6j4+fcwTk77n5w2knzeZtMkTOLzJOyVxXTi2ZmWV1yOim98MHqDj3HO5fs5tgBYGeZY9nQXTLrudmBLNjScD67dd2Bis/a45LEU16m/LL5958sh3KyroqVDUjtYj8GWiZXYmCHq6NhW1JIzmYAoDQFes7Ro9fdjjqik8vt99fPyxp9zHia8/6T7e/9YLrH//S35/93N328o5C1kxt9Ru2WqwbV4NoOXYL1UlKTcIfhgiCDCH1/wFNSILZ7zJmBFaecRHbyyVTjrUwKihN7rTC+hDK1/orgnmQC2KxmmrWTirLNC+Cb0602NTx3c+qlUFKoWiIlqNwEubd2hhqENUuaDZnLEZQdi1uLqsJM9MnVRPVcROR4+6j7vtSXQf91j3B5HPPEzUX//ibuuyfzNd92ys8fi6Ai2Uz+CEvHRPWF+AFdrog1rEz/WNKz2Lz2fr4G6fEsz2roLwsQMqu61GBIZqYaJOS80E3pCZR4kBLplzLU8s8vzsslN9V4Re0Tpp/n+JPiJyeALfDRO8cIn2ksOriCVv7jj0oLc7cTqdFKV6ioBEnK5fzdb8rMrT6R7ZspuVF1xGXmYOAYWeTInJB7XNPHabHbMdnPX0XzcWbdr2Z0NvV1Iy18u5ef5rHLqmE1Mn3levZwe69gFIW/ki7xURmZzDoXiYNOZeHpn6tLs9+cAf9bJDoWg1Aj9q+CLCFozmhovuJCsEVoxvumRY9cVu0AR+1cN/pddHa93t7VKrTlH7ztTyb3dpN8DG95aWu36WrJuupsvxPZwaew7heZIMlxfjzFFN4HMzXbPNgKbPA19Tivtr4ZxFLu9dXLvBPDF/FaYq9iLUhIi2rjWIwprlhDdZHMggA0Kno3vv8e729GO762WHQtFqBF6nN3DDrKWMGraIz/4cw5wF91R/UzPFYRDo7ZLOy8sX/zgRW/E9dh0MDvOuXOV0OinM9UTC5CRXnCrX6XQSWuzJFBlsgVRXhGnBac0VlH7S5RKq5wJlYzJg5mW8cKmOrAt7+PS50bEJFJpBX1BIcUFhtb70gBJwBGjffIKCot2++IKUYz61S9H6aLq6ak2E3mDk5avWVt+xGeMwCMxWia4CL5PDVL7NCTy9SMdlIhbw7IDdtvxHhNHK2ZyLspKdl3kZ5aM8CmLNcLQEa/ppAE7v3EI7QNeukk+YZsi5o24nOiqB3t3O9+lzjcYgCgLBUGhh5/gJ5Ea1Y/pP3/DDc68R3acnwy6aitPhYMOHyxl+2QwCrZ5cOQAXnXcVrHgPe0aqT+1StD5ancD7Aw6DwGD3zAr3d4Jig2DoMYnBKfhxMEzbIflogo6uqZIfphp49YplbPnuQ2CD+76Qh/7s/eBKysydOryz3Fc9EReLQyRDrib+udvX0w7oMGi0D15h46DT6enXa3aDPLswGEKzrYQXOQkvOkJWSjod//tP7eJF+1n12HN0+fwDfk08TGeAIE9is+EjriCV9+j4+1Ecdgd6Q/NIqaFoebQaF40/4dTraJvpOTdLHbn9IwHQOSH2+vN48AETY65aQNY1fXnz2u+Jie5JbMeqXRG6Um6Y0qQf3wPA83M9vy7RY0eSFwz6PFd6giNHORELg0Y0jGC2NFLiDbQ74/kQPvj7Kvex0+lEv1ULU81N1tp1IR6/f0SElsI6rMDOuqXNuwavonmjBL4FIvVl3jYBsbE93acLpr3M8ut2csG4v3DvpcsIdSXOau/aBVsZekvFSa4Ks5IBmNtpBoVmzc8/dep9FASBqdAVKWIvwR4gCA9v2vz6zQVDB+/NXun7PGGo2anp2KX2YWrM0741GcM9GTiFTuf2w2du+rihTVX4MUrgWyCijO89pZ2OwAht1VPnrDz8s01cT6x6WD5KsHyUdxRRRij0PmDhu6eWsPOH3zm40bPj1ZqvhU8GhMXynzvDWXNTBwIDIykOEgQUaZE7BrvEYWi5kUm+JqJLH69zW5JnX0LygT/c72GfHa6fbYT32sWVV/2ZIjM4i8uvfygUNUX54FsgzlIfy5+NFXS7dAKBudVncDQYzCx9uC1T4ieAdPKV+JyLN2pKkxENMfmQ8OHr8KG2MMsBbWes05UVMSQihjfme2aiJUF62mS6BN4mcRiVr/gsXYaOAzzFO4wZnhz9Wcl7y/UPaeM94z9nyI2sM/2DzgcK+PrS65j12dvoWsAGMkXzQv3GtECcBs/b1mvQOVxx/hLCu3QAYN3wqkX2lStXM3vCYmZPfIr4EM+sMaSCItlrli4DwFGk5VQJjvKeZdqCTQQXaT5low01gy9Fz77eeY6Cczy7WgtWrsFg9/6mFVPB+kiJGUKKnPTYu5H87PptYlO0Tnwi8EKICCHEMiHEASHEfiHEOUKIKCHEj0KIw67/I30xlgKswdoXr92dBQPPvwSh0zFgyGyefiiU2Tc+WuPn6CM9b8maieU3KMX+7VHOnEyBEs1PHB7Tweu6DAnE6IDcjEyMdnCqGbybwMBInpur45FrtJ9JeI6nmHb3HYdpm+4t8F36lI8+spYKec08pWLiFbXHVzP4V4BVUsrewCBgP/Ag8LOUsgfws+tc4QP0F4/kg0k6Um8aTJ+eMwGtEtSHCzczpO+8Gj/HHOXJh3/dtUsq7LP17ZfAlVMlKtZ7AVUXqCVQz0o5hkkJfDn+cv0S/rXofax6bXNYaUx2+HCijo29BM9eqSMkpG25+61mz59nVurxhjZX4YfUW+CFEOHAeOBtACmlVUqZA1wEvOvq9i5wcX3HUmjMn/kK599wJ3fMqV8IXXCUx+/btfM4PhuruVjW9PO4WqyHthF+UkuGFRzs7efXuXLs56QlY7bVv1CGv9GjyxTaxw2h2PXlaEtP7+sD+o/CfPt0nrnu7Qrvt5s8f54F6acq7KNQVIUvZvBdgHTgHSHEdiHEf4QQwUBbKeXZasapQPkpiqJO6HR6xg27ud5ZG8NivV0ufYu1NLemjjG8NV17dq8/TtMpyUJRAOXG07ty7Gcc3AeAI6iCbbQKN46YQK/zhH7juOK8l+gUX/HmsECLx41TlN041boU/oUvBN4ADAVel1IOAQop446RUkqgwvg9IcRNQoitQoit6ekqPWpjEtWhi9f5mfPi+X6ooM2FU5gx2zs/fHEFKWZMIdoHQqdXPwJAH9c8SiA2N8JddT90nbwrXXXpM7bK+7ZOCnXXirXmZlbZV6GoCF8IfDKQLKXc5Dpfhib4aUKIdgCu/yucgkgp35RSDpdSDo+NbTl5TPyBtvG9AEhxrbVeN+8/dL75UmZMepRRw73rw8ZVoC/m0Civ85je9cuj7q/kuSbuHUdPZPEVnj+5mNiuldyhccO1r7PiGu1nbM9XUTSK2lNvgZdSpgInhRC9XE1TgH3A18BCV9tCYHl9x1L4lvCI9jw3V8fKq7RdlIGBEcyZ8BRCpyMktC2Lr9Bx1y3ar0hFic2Coz0z9rfP0zF00oJGsbul8flsIy9comPkuVfz5JzX3O06fdXbUNrHDea6ic8C4CyqOBGcQlEVvtrodAfwoRDCBBwDrkP78PhUCHE9cAK43EdjKXyETm/gmTs+Iia8S7lrQqfjX3d8Q3BgNI8dHUNWuGsVvRQ9Ro3nu16vEpMnmXPFncRE+zbtrr9w163vYbMXExLSlradHJyuxb2x7buSCiSsS2oo8xR+jE8EXkq5AxhewaWWV9W6lRHftvL8NDGRmgth3i1/ISo0vtz1uLYDaPfw9exL2cLdI29sMBtbOh3iBruPw0LjaiXw4RHtSAVCixzV9lUoyqJSFSiqZXi/yl0v54+6F99mU/dvahv5VNqNk30mi8g2UVX0Vii8UakKFIpG5l+zdLwyu+Z/en900/Yl7JijUjEraoeawSsUjcztt/wdnai5wDs6RcPRDOIyM0lLSqFtp3bV36RQoGbwCkWj07f7+fTudl6N+5uk58/04LovG8IkhZ+iBF6haOaYLhzFrgTNTZN76lATW6NoSSiBVyiaORdf8FeKrtF2vcote+r8nOKSiit2KfwXJfAKRTNHp9Mzc/K9AASl1SbI0sP+jTtJHDSQ1f/9nPS0LF+ap2jGKIFXKFoAsW178Xs/QWBx5SUZq+Lwz68D0Pa5v5AxYSwn9h2t5g6FP6AEXqFoAQghCAoKJLRQq6BVW2yWAq/zQ+s+qrL/mZR0Th5NLtf+/ZL3+P2T72o9vqJpUAKvULQQHGHBGB1wcOtOvrjnKUosVgBys3NZ+eJ/cDicbPr6Fz5feBf5ud6C7sj1TlZWlH2GpAoEHCA9OY3MSeMpmDmN/Zt2YbVru2gzUzPo9NpfiXr8Huw2ewO8QoWvUXHwCkULwdAuDkjHfu2V9HFKtp3TjTGXXcFvt95Ajx172NwpAstrz9I3tZgt/+vK5Jvvct+rz/QW+J7v/ETuuz/Dvn3lxtm5fCnuSgEL53EU2DdnIcbcQ5zNNrT7118Zct40Uk+nExwSRGhYcEO8ZEU9UTN4haKFEDdYKwxicGp+eMff/86OfgPosUOLrEnduwIrWv1c61cfo5Vh0Ig6WT7dsMEp+friy8q15yWXj9Tp++W79Phlg/v81K4VAGRPHs/WC2oe069oXJTAKxQthGET5nudx+QUYXZ4XCX2tNMYXTnJOh/PZdXkaSQdPgFAUKGDdQMEr8/QsTPBU5Kxx4E97Nu4y+u5jqzKC++UuL7zl+RmuNviMrNIP6UqTjVHlMArFC2EsND2vDddlGvPCAOrHigqIKgIjsVp7Qkpp8ibfQFWm53gIggKDuYfL+7E1t278pa4dh5bBw5i74ad2jjH08kKgdtv1XPr7Xo+ebInD1yrFVRfPVwb31GQxzePPOd+xraPXmqAV6yoL0rgFYoWxFV/epGvFvfzakv8y1SKA0BXXEJwMWR0DuT3PpoQ66Vk/bnnopcgQ0Mw6AwYemipn52lPiuCrVaOvn4fdruDuNMWDvbQ88tde1h9xx6euHw57966kjfui6b/DVpa6KCjZ+j++bvu+wstaQ38yhV1QQm8QtGC6NdjBvfOec99/vA1eubPeIFiMwTllmBwgiE0nLYleneftrm5AOjbxAAw5arHePg6PYfe9q67mxds4cDGjZjsoG/nPcuPDO/EKzesY+Lo27DpoduhXK/rjrRMMtOy2P7bVp++XkX9UFE0CkULw2QKch9/8eAuhE5HiRnCcjR/vC48gjNtsuh+zPu+mD5DAWgT3ZMvH9AWUvfzjvu6wRDI0S9epycQPeacCsc2GMzoKgjDH/DTIc78NJYAIH/jZkIjQuv+AhU+Q83gFYoWyN5OkBbhKSBSEqAjKk+7FhDXjoRFC3l8kWf+9s5UHYMnzS33nE/G6djWXfPVDPrxJD1XbgNg0gX3VDr2Z+frWdNP8OOQ8usBAL+9sLhOr0nhe9QMXqFogYQ/fTOZxZ6cMsWhBsCKQ0CP8TPoP2gWk8/9MwvzB9A9vj33XPYGsVHdyj3nsgf+jtVRDBc97NUeHBxd6djX3f9fkjP2YivI5bVtH6I/VsCiH5zuCB52/lyt/ZkZOQQEmgkODqzR61XUDVE6VrapGT58uNy6VfnwFIra8sENoxm2Lpe9CXDJyj3odJoP3uqwohd69Dp9lffv793H67zPgf01HvtMznGWP72Ic79NdbfFrdtAZExEleMlt2vDtF9/q/E4isoRQmyTUpari61cNAqFH2CcOoLPzhVkLhzpFncAk95UrbgDfDzJVRawi+Cf15hrNXabiC50GDcBgN2dtefs/Pa9Svtbii0AxKeo2PmGRrloFAo/4NLL/kHaeSfoENW9Tvdf8/Bb/HLJp0zsu4C57YbV+v5pMx/idX0SsTkh8PSPZB3ZVmnfI9vWU/1HjsIXKIFXKPwAg95YZ3EH6N5xLN07jq3z/UaDmTtnLSU5aTv5/EifZZv5pdsHTL7uqnJ9k//4lc51HklRG5SLRqFQ+Iz28QPdx/aPXmD7b5vY37sPK6ZOdbcXHN/bFKa1SpTAKxQKn1Ha/58dDmkv/AmArsmnAFj+1L+I3XLE3aeooKhxDWxlKIFXKBQ+5ZNxmqwEWST5Jqu7PSczi54fvkqbDE9t2JRj5dMVK3yHEniFQuFTLn/oZXYlCLofsdF/n0fg1/33v+7jYpP2f5py1zQoPhN4IYReCLFdCPGt67yLEGKTEOKIEOITIYTJV2MpFIrmS9+u09AFlo+T6fbWW+5jh0t5Mg9qqYozMnIpLi5pFPtaE76cwd8FlN4d8TzwkpSyO5ANXO/DsRQKRTPGFhrgPl49oHxKg6R22v/dl67kTEo66eeO5tdLZzWWea0Gnwi8ECIemAn8x3UugMnAMleXd4GLfTGWQqFo/jgjwwBIai+ImuhJXPb2NB3vTtFRsHA82a4qfxsfvxWALseSKbGqWq++xFcz+JeB/wPO5pmLBnKklGffrWTwlHksjRDiJiHEViHE1vT0yivJKBSKloM5qi0ANgNMme/Jc3Pjja/wl5c2cc28N9h9zwgAOq/3+OFXLbqycQ31c+ot8EKIWcAZKWXlW9eqQEr5ppRyuJRyeGxsbH3NUSgUzYD2kyewryMkzulFTHQ3Ppqg41B76NJrDCGmEIQQ3Hzle5yIA1OpSXvPrbsqf6ii1vhiJ+tYYLYQYgYQAIQBrwARQgiDaxYfD5zywVgKhaIFMObcm/jtRROz+2sz8pue/B97k37FZA7y6pcdY6BzqrdbRkqJ5uVV1Jd6z+CllA9JKeOllAnAfOAXKeWVwK/A2QTUC4Hl9R1LoVC0DIQQTBx0HUa9FjzXse0Azh9xZ7l+1ngtLXFWiKdt3+9rGsXG1kBDxsE/ANwjhDiC5pN/uwHHUigULZDIAVqG2/wg2JWgzdpPbF/VlCb5FT4VeCnlainlLNfxMSnlSClldynlZVJKFeSqUCi8GDPnNj6YqiP9zmmYbroEgKITh6u97/D+4ypuvgaobJIKhaLJiInqylP/3I1O6CjIP8P+Jz/HdDiR/IJiQkMqrvZUmJePfc4MfuzfndnLvmlki1sWKlWBQqFoUnRCk6GQ0DaktBH0OFhI8vChfHn3I1itNvItNs6kZXEyMQWA4zs3ANBjzxGsNjtp6bl89fzrnDx+ij827qE5ValratQMXqFQNBuKIoyQpOWv6f3dF6w0FtLz6+8RgNUg6LhnH6mHt7k31Xx/6Sy6HzpBL6DgnSUEAj/96Ram/emuJnoFzQs1g1coFM0Ge2So13mXlZq4A5jsEofDSd7xg+7r3Q+dKPeMrJ2fN6SJLQol8AqFotmgD/YWeFOZzAXLr5lHu+83U2yCXFdIfYkBvhkpeH+SJmeB6SrH/FmUwCsUimaDuXdXAH6dHkZqlKf9remaVPXZtoeIPMmReMjW0t2w9cIO3PzGOp5+bTebBulJOFxIWpLaVwlK4BUKRTNi5nUvsOLeHsx9/EN2TIwAYMU0M39/eQ9r+3l2t1qH9Sb1qpF8MV7HlFueIjwoCp3QETBsCEYHpM2YxsoLp3J45x6O7z/ON4v/1ioXX0VzetHDhw+XW7dubWozFApFMyAnP4Uf97zH7BF3YTYEsGnL+4Rd/SwAxx+ay4yFT2Fz2jDqjO57Vn/xMm0f/rf7/MCoBHpvSgQg5Jsv6dijd6O+hsZCCLFNSjm8bLuawSsUimZJRGg7LjvnAcwGLbf8qBFXu6/1GKEV8S4t7gAJ/Ud7nZ8Vd4BTBzc3kKXNFyXwCoWixbB8soGUSOjac0yF1zt2HcaJMklpE9to/6cd2N3A1jU/lMArFIoWw43PrSTmw1fQG4wVXtcbjIQ9d59XW3Z7MwAhK75rcPuaG0rgFQpFiyE6rCMDu55XZZ8xY6/n0Cvz2NxXW5SVMVrGShzOKu7yT5TAKxQKv+Oi6U/gGN4DAFP/ruzuZyKoqPkElDQWSuAVCoVfcuX9H/PHyzOZc+NrWKODiSiAr/58S1Ob1agogVcoFH6J2RjElee/iEFvRB+vZa/pteo3bHZHE1vWeCiBVygUfs/U2//K1u6aT37lQzc0sTWNhxJ4hULh98RGd2fKUi0JWfCWbRTkt458NUrgFQpFq6B9mz4AdEi18cufr2hiaxoHJfAKiGfdmwAAD55JREFUhaLVsNPlponefZDlC+dSVGhpYosaFiXwCoWi1dDhoT8DEJUHPTft5ecX/6+JLWpYlMArFIpWw7ixN3Ggi0f29BtXk5eTz/IbFpB2Kq0JLWsYVMk+hULRqii5+Bx46XdSIqHTCRu/PHEDvdbtYtvNF6J3CEIW3UXaljXoUk5y0XvfIoSo/qHNFJUuWKFQtCocDjvf/vYszqRcej+3EqsRTLaK+2aHmen57S/EtNGqjxRbrPzw2AN0Ov8ihkyeWKPxjh08gRCCLj07uds2rfiBzP07mXHf/fV8NRoqXbBCoVAAer2BiyY/xswrnqYgQBP3nOCK+0bmlfD7/fPc578smETPr1fhvPc21v7vfzUar+Si87HMns76ZR8CkHRwP2H33kWX/yzl2K4dHN6+hW8um8r2H1bU+7WVRQm8QqFolZhMgewcbALgzP9d7G5PjtYE/4chmmsm8lAyRYUWfv/+e7ruzwIgqFgS88TiasdwOj0JzopffQ4pJTu+es3dtuv5h9jz1dt0332KU0lrfPK6SqN88AqFotUy4/mPWLPmP8yb+ywf5WVgyc9mwORLCQ6L5a6uU1n6l+mcsyyJQ+cMJcqqubNXXx7PxE+TAXA4nOj1lc+Tkw7scR+3T7Gz/qsPKCmVl77XtkTYlogTGDRlvs9fX7198EKIjsB7QFtAAm9KKV8RQkQBnwAJQCJwuZQyu6pnKR+8QqFoThSXFLBr9AjCij1ths/fYPPSZxm6IolDwzox+4NVFS7Ebl+7laQ1H9Dz/e/5dWYUk1ZkUWKC7HBBvlnSI9nTN7EdnP/Lvjov6DakD94O3Cul7AuMBm4XQvQFHgR+llL2AH52nSsUCkWLIdAcwsEeegDW9xH8NK8d3fqcy7l3PcuRdtBzWxJfzZvDurEDWHXROKw2OwCH/thMwI1X0/P97wE493It3t5shbh0SVFsIMmuSlP7OkLhoukNEq1Tb4GXUqZIKf9wHecD+4EOwEXAu65u7wIXV/wEhUKhaL5MfuUjNj84hmuW7eCOxb+g0+np3GkYcsFMAHrvOkh0pp3OBzPYOGkw3/59MY4rFno9o/+IWay6zhNF44gMJ3Gidt7tmWeZe/XLDWK7T8MkhRAJwBqgP5AkpYxwtQsg++x5ZSgXjUKhaCmkphwke5I2b31vXgjXfFJQYb8dXQQLvtuHlJLXX7+SkO+2E3/zDYy/4E72Jv3GoC5T621LZS4anwm8ECIE+A14Rkr5hRAip7SgCyGypZSRFdx3E3ATQKdOnYadOHHCJ/YoFApFQ/PPW4ZgLLJzy3u7+e2nN2nzp5fc176YYiTMFMRVj39GZERHd7uU0ufumAYVeCGEEfgW+F5K+Q9X20FgopQyRQjRDlgtpexV1XPUDF6hULQknNKJQLgF+7VXLqXzl/sovG8+c2c+ik40TiR6ZQJf7zBJl/vlbWD/WXF38TWwEHjO9f/y+o6lUCgUzYmyAn7bXZ+TeWMG0UExTWSRN76Igx8LXA3sFkLscLU9jCbsnwohrgdOAJf7YCyFQqFo1jQXcQcfCLyUch1QmUNpSn2fr1AoFIq6oVIVKBQKhZ+iBF6hUCj8FCXwCoVC4acogVcoFAo/RQm8QqFQ+CnNqqKTECIdLaSyNsQAGQ1gTn1QNtWM5mgTND+7mps9Z2mOdjU3mxrLns5Sytiyjc1K4OuCEGJrRTu4mhJlU81ojjZB87OrudlzluZoV3OzqantUS4ahUKh8FOUwCsUCoWf4g8C/2ZTG1AByqaa0RxtguZnV3Oz5yzN0a7mZlOT2tPiffAKhUKhqBh/mMErFAqFogKUwCsUCoWf0iIEXjRENVpFo6Deu5aLeu9aPi1C4BU1QwjRS4hGKiFTc5qbPc0S9d7Vjub0sxJCdGhqGyqj2fyQKkIIcaEQ4mPgQSFE56a2B0AIcbEQ4qmmtqM0QohpQohNwA00k/dUCDFTCPEt8JQQYmxT2wPqvaspzfG9AxBCzBZC3NPUdpxFCDFVCLENuKWpbakUKWWz/AdMBTYD5wOPAi8CM13XdI1siwD0aH+ERwAbMK6Jfz4CMAJPAoeBS8peb0LbhrneuxnAfLRQsWvVe6feuzraZAAeABIBJzDY1a5vovfOBLwG7AAubi7vXUX/msWMoRKmAt9KKVcB/wZCgUVCiGAppbMxDZEaDjSBGALcBjTpTNBlkw3tF36ZlPILACH+v72zD9aiquP453sviQJXhDHsqkO8a5rG8KYzBEiCJokMElEQiJoljaFSo2aKEhhOMfRiMzUxExGFTWUyONKL4zAMEmUoGWgFMokWYr4kQ6E0yq8/fufhLk/IfS53d5/DnfOd2dmze87e53P37P72vPzOORoVFkGvp8YBG8xsLb4W7x5grqTuZnawzLbdlHdtVjR5V5GZvQX8FTgbmIfbA0K+ls1iZvZfoAuw2sxWS2qQ9IFKfNlMR1M0Bl7SXEn3Sqqs3fpbYKSkE83sn8CbeEnsmpKZlkn6VDi13sz2mdkyoGtYb7bU9sAM06fDqe8CzZKWS9oK3IIvgn5NSF/4C5lhui6cWgdMlNTDzN7AS8178VJYKS9Byrs2M0WTdxmurD142MzeNLNvAL0kTQ/pSvkgZnimhVMLgVGSlgBPAoskfU/SpWXw1Kq6G3i5bgamAZuBBZKuAv4C7MYX7l4HnIyXKJrKeCklzQamAw8AMyV9EeiXSTIfmBdehFJqFFVMMyTdARwAVuPVxqnAFSH+Skm9i34hq5g+KelLeFX618BKSRvw+3YvcIqkrkXyHIEp5V1tTLHk3ZHswWygRybZPOBrAKEmVCbP3ZKuNbOdeN6dHeKmA9uAyZLiWXW73m1E4RleA4wN4cuAr+MPfCNera60vc8AlpXEtBKYHMLDgAXA/Ko0P8dLNk3A1DowLQRuC8ddM+n6Aj8GmuvE9IVw3BsYH8JjgOUp71Le1cCVtQcfBpYCM6vSrMuwjiuZ51vAx8Jxt0y60cAqoEtZ96q1ra4l+ExJfDMwCsDMfglsB4YDA8xsi5k9HNINBX5fEtMW4PLAtBnYBJxR5VVwK7AY7yh7Tx2YNgJ9JY00s/9kLrkKOAn4V52YBkkaZWbPm9kjId1HgJ1F8bTClPKudqa65F0VV9Ye/ArPo3MlnZVJPgf4qqQ9QCFuikfh+TMwVNJZZvbvzCXjgf14c3IUKtXAS2oMewFYS/X4Wbzp5bxwvB4vWTWF9BMkPQ68F69O5s116D5kmDYCDZJGh+NtwIvA6eGaAXhP+mpgiJndFwHTFElP4dXqOWaW64PWBqbdBKMpabSk9cBAvM05T57D2qhjyLt2MBWWd21kKiXvwt9vfAeuI9mD7rTYg8HAMtwWDDGzFXXgOTnD83FJ23D7dLuV7ARyNJVi4CWNlLQCuENSTwv1mUwHyePAW8AlkjqZ2TP4V3l4iN8BXG9mU8wsl5KNpBGS5sJhGZk1YjuAp4FpkhrN7O/AaUCfEL8XuMHMrjSz3XVm6hvit+P3aZaZvRQJ03PAZ81sspnlsrJNYFoG3Crp3ZnzlRe0Xnl3LExF5117mJ4j57wLvz9M0kpgvqT+mfOdQvCd7EFl4YxXA9fUPPIvB55d+Ed5lrlDSDQqo7OyH15aWod/4RZKmgAtHSRm9ixeDeoP3BYuPYA/YJjZDjN7Mkemm4AH8Q/OZeFcY/itihHbB2wAOgNLwseoB/5wYWYvm9mOSJheCem2mtmmyJieN7Onc+JplLQY983eCAwB7pJ0WvitittcaXmXA1PueZcjU255F7gaJH0bd3N8FGjGOy1PktRg7g55NHuwK8S/YGZbI+LZZGYb2stTiIpu5McHS/wkhHsC1wHfIXQiAYtw17A+eI/0GuAJ/KYXMrACmIR33k7B3eeq4xcAPws8zcAPgN8FpkIGVySmmngagRuAQeH4DPzF65OY4mbK/O5U4JQQHgj8EDghE7+wTHsQG0/u/18BN2xieLguDMf98FJE73B8Du52dTPwQbzXeUDm+m6VG14gU2PYTgTWAnPD+QbgvMDUP3N9A9CUmOrKNDwc9wz7zmG/GhgWwucnpniYqrguqDo/DngdeAQfpX4OLV4ohdmD2HiK3vLMyGbgIbzKdyfe03xpiFsCfD6EG4GZwF1A9+wDVsDDdTSmymInFwNPAace4frEFBfTJVVpmgLT6YkpHqbWnqkQPwyYEMJfBr5CKAQWwRUbT1lbnjdwInBL5vh64IEQnoRXAS8Ixx8CHi3hIatm+gzwYFWaBry6tSAcjwj7QuaUSEztYlpdleZiYFUIdwMGJqb6M9XKlYm7EPgNwae8CHsQG09ZW7s6WSXNknSRpM54J8XKTPSruGcAuO/6FmCppG7AucAuSV3gcO+M9qoVptfwL/chL5Dw24twT4O9wBBJspCziSkqpmdCuor3VQ/gBUlXA38ABgfWxFQyU1u4jqChuHvm24ErF3sQG0891Kn1JIdLknA/2VX4ZEk78Y7TG83sRUnvMveOaSYMLzazPcA35VP+fh/3ppllZvvz+CeOkakycVJ/YDneT3CT5dA7n5gKZ6oMT5+Ej25eAUwzsz8lpvKYjpUrXNeEl5TvAV7Cm3Df6Gg8dVcbqzmNYT8I+FHlHHAf8IuqNA8RhhADvcK+E/l3Lh0rU6UTqhdhGHJiOm6YTg37TwAfTUzlM7WTq+K1Mh64oqPyxLDVVIIPvs8LgUZJa/FRXJXqy9uSbgR2SxpjZuslnQC8DGyXdA9wuaSLzAcp7avlN0tiGms+MCGXwQmJqVSm0WZ2fx48iakuXGOsZSqEDsUTk1ptg5c0Bvf77IEP2V2ITyE6VtIIONRGdTfuWwvuVjcbb/dqwr+Uuc2tkSPTa4npuGXam5jKZcqZ6/WOyBOdaqj2jCIzkxs+KnUOfoOeCOca8HavnwJnAiPwAQODi6h2JKbElJjKZ4qRKzae2LZabmAXfChzpe1qBrA4hP8IfC6EhxFGrBYOnZgSU2IqnSlGrth4YttabaIxs/1mdsBa5q8Yj7dfAVwNvE++QO/9eFXp/2avy1uJKTElpvKZYuSKjSc21ewmGToyDJ9tbk04vQ+4HXg/8Dcz+weUuqxXYkpMialkphi5YuOJRW0Z6HQQXwn+FeD88FW8EzhoZo9Vbl7JSkyJKTHVR7FxxcYTh9rSnoMPBDgIPAZcW+/2pcSUmBJT4oqVJ4atMpFUTZJ0Jj5R2FIzO9CWD0lRSky1KTHVpsRUu2Ljio0nBrXJwCclJSUlHT+q66LbSUlJSUnFKRn4pKSkpA6qZOCTkpKSOqiSgU9KSkrqoEoGPikpKamDKhn4pKSkpA6qZOCTkpKSOqj+B0Q0v52Gs6TVAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset_simulated[['high', 'low', 'open', 'close']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_simulated = ohclv_to_features(dataset_simulated)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 15.4 s, sys: 245 ms, total: 15.7 s\n",
      "Wall time: 16.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "dataset_warmup = dataset[str(START_YEAR):str(WARMUP_END)]\n",
    "dataset_train = dataset[str(WARMUP_END):str(END_YEAR)]\n",
    "imp, IMPORTANT_FEATURES = calculate_important_features(dataset_warmup)\n",
    "\n",
    "X_train, Y_train, P_train, T_train = createXY(dataset_train[IMPORTANT_FEATURES], dataset_train['close'], training=True)\n",
    "X_test, Y_test, P_test, T_test = createXY(dataset_simulated[IMPORTANT_FEATURES], dataset_simulated['close'])\n",
    "\n",
    "mmcs, pred_prs = train_and_evaluate_n_times(X_train, Y_train, X_test, Y_test)\n",
    "bagging_strategies, bagging_returns = backtest_predictions(pred_prs, P_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_mmcs(mmcs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_backtests(bagging_strategies, P_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'benchmark_mean_returns': -0.0016298815517014648,\n",
       " 'strategy_mean_returns': -0.00016988540921789337,\n",
       " 'benchmark_sharpe': -0.7976058116154443,\n",
       " 'benchmark_sharpe_smart': -0.7854766881420959,\n",
       " 'strategy_sharpe': -0.1754275958955971,\n",
       " 'strategy_sharpe_smart': -0.17352309077439634,\n",
       " 'probabilistic_sharpe_ratio': 1.0,\n",
       " 'deflated_sharpe_ratio': 1.7503916760528936e-125,\n",
       " 'information_ratio': 1.5076257253160383,\n",
       " 'minimum_track_record_length': 8.09670397911453,\n",
       " 'benchmark_drawdown': -1.48,\n",
       " 'strategy_drawdown': -0.57,\n",
       " 'mmc_mean': -0.001590932580995177,\n",
       " 'mmc_std': 0.02061330549368497,\n",
       " 'mmc_sharpe': -0.07717988662626528,\n",
       " 'model_certainty': 0.02122105263157903}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculate_all_metrics(\n",
    "    P_test, \n",
    "    np.array(bagging_returns), \n",
    "    T_test,\n",
    "    mmcs, \n",
    "    pred_prs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "column_importance_ts = {}\n",
    "for column in imp.T.columns:\n",
    "    if column not in column_importance_ts:\n",
    "        column_importance_ts[column] = [imp.T[column]['mean']]\n",
    "    else:\n",
    "        column_importance_ts[column].append(imp.T[column]['mean'])\n",
    "column_importance_ts = pd.DataFrame.from_dict(column_importance_ts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x14a447748>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "column_importance_ts.T.plot.bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
